package main

import (
	"fmt"
	"time"

	"github.com/gorilla/websocket"
	"github.com/valyala/fastjson"
)

func TI() string {
	return time.Now().In(time.FixedZone("CST", 28800)).Format("\r[01-02 15:04:05] ")
}
func nowTime() int64 {
	return time.Now().Unix()
}

var chanSend chan []byte

func send2server(Context string) {
	//fmt.Println("发给服务器:", Context)
	chanSend <- []byte(Context)
}
func init() {
	chanSend = make(chan []byte)
	go func() {
		for {
			websocketClient()
			time.Sleep(time.Second * 5)
		}
	}()
	go func() {
		for {
			time.Sleep(time.Second * 30)
			postMonitorRooms()
		}
	}()
}

var (
	monitorNewRoomChan = make(chan [][2]int)
)

func websocketClient() {
	// Connect to WebSocket server
	conn, _, err := websocket.DefaultDialer.Dial(fmt.Sprintf("%v&maxroom=%v", SERVERWS, TomlInfo.MaxRoom), nil)
	if err != nil {
		fmt.Printf("%vdail err: %v\n", TI(), err)
		return
	}
	defer conn.Close()

	// Start a new goroutine to read messages from the server
	go func() {
		defer conn.Close()
		for {
			_, message, err := conn.ReadMessage()
			if err != nil {
				fmt.Printf("%vread err:%v\n", TI(), err)
				return
			}
			//fmt.Println(string(message))
			p := fastjson.Parser{}
			js, err := p.Parse(string(message))
			if err != nil {
				fmt.Println("Error parsing JSON:", err)
				continue
			}
			roomids := [][2]int{}
			if js.Exists("roomids") {
				for _, v := range js.GetArray("roomids") {
					vs, err := v.Array()
					if err == nil {
						i, err := vs[0].Int()
						if err == nil {
							online, err := vs[1].Int()
							if err == nil {
								roomids = append(roomids, [2]int{i, online})
							}
						}
					}

				}
				//fmt.Println(roomids)
				//roomids = [][2]int{{7117440, 1}}
				monitorNewRoomChan <- roomids
			} else {
				fmt.Printf("%v收到: %s\n", TI(), message)
			}
		}
	}()

	// Start a new goroutine to read input from the user and send messages to the server

	for {
		input := <-chanSend
		err = conn.WriteMessage(websocket.TextMessage, input)
		if err != nil {
			fmt.Printf("%vwrite2server err:%v\n", TI(), err)
			return
		}
	}
}

// // 创建一个映射，用于存储每个conn对应的互斥锁
// var connMutexMap = &sync.Map{}

// func writeMessage(conn *websocket.Conn, message []byte) error {

// 	// Get the mutex for the current conn. If it doesn't exist, create a new one.
// 	connMutex, _ := connMutexMap.LoadOrStore(conn, &sync.Mutex{})
// 	mutex := connMutex.(*sync.Mutex)

// 	// Use the mutex for the current conn to protect the write operation.
// 	mutex.Lock()
// 	defer mutex.Unlock()

// 	// Set a timeout for the write operation.
// 	timeout := time.Duration(time.Second * 5)
// 	err := conn.SetWriteDeadline(time.Now().Add(timeout))
// 	if err != nil {
// 		return err
// 	}
// 	return conn.WriteMessage(websocket.TextMessage, message)
// }

// 在这个示例中，我们使用`websocket.DefaultDialer.Dial`方法来连接WebSocket服务器。需要注意的是，在URL中添加`password`查询参数以进行身份验证。

// 在连接成功后，我们启动了三个goroutine：一个用于读取服务器发送的消息，一个用于发送心跳消息以保持连接，一个用于读取用户的输入并将其发送到服务器。

// 在读取用户的输入时，我们使用了`bufio.NewReader`来创建一个读取器，然后使用`ReadString`方法读取一行输入。我们将读取到的字符串使用`strings.TrimSpace`方法去除首尾空白字符，并使用`conn.WriteMessage`方法将其发送给服务器。

// 最后，我们使用`os/signal`包来捕获中断信号，以便在程序退出之前关闭WebSocket连接。如果接收到中断信号，我们
